﻿#include<iostream>
#include<vector>
using namespace std;


//class Student
//{
//public:
//	//进⼊校园/图书馆/实验室刷二维码等身份认证 
//	void identity()
//	{
//		// ...
//	}
//
//	//学习 
//	void study()
//	{
//		// ...
//	}
//
//protected:
//	string _name = "peter"; //姓名 
//	string _address; //地址 
//	string _tel; //电话 
//	int _age = 18; //年龄 
//	int _stuid; //学号 
//};
//
//class Teacher
//{
//public:
//	//进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
//	void identity()
//	{
//		// ...
//	}
//	//授课 
//	void teaching()
//	{
//		//...
//	}
//
//protected:
//	string _name = "张三"; //姓名 
//	int _age = 18; //年龄 
//	string _address; //地址 
//	string _tel; //电话 
//	string _title; //职称 
//};
//
//int main()
//{
//	return 0;
//}



//class Person
//{
//public:
//	//进入校园/图书馆/实验室刷二维码等身份认证
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//		cout << _age << endl;
//	}
//
//protected:
//	string _name = "张三";//姓名
//	string _address;//地址
//	string _tel;//电话
//
//private:
//	int _age = 18;;//年龄
//};
//
//class Student :public Person
//{
//public:
//	//学习
//	void study()
//	{
//		identity();
//		//...
//	}
//
//protected:
//	int _stuid;//学号
//};
//
//class Teacher :public Person
//{
//public:
//	//授课
//	void teaching()
//	{
//		//...
//	}
//
//protected:
//	string _title;//职称
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//	s.identity();
//	t.identity();
//
//	return 0;
//}

//class Person
//{
//public:
//	void Print()
//	{
//		cout << _name << endl;
//	}
//
//protected:
//	string _name;//姓名
//
//private:
//	int _age;//年龄
//};
//
//
////class Student :private Person
////class Student :protected Person
//class Student :public Person
//{
//
//protected:
//	int _stuid;//学号
//};
//


//namespace zsy
//{
//	//stack和vector的关系，既符合is-a，也符合has-a 
//	template<class T>
//	class stack :public std::vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			vector<T>::push_back(x);
//
//		}
//
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//
//int main()
//{
//	zsy::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	st.push(4);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	cout << endl;
//
//	return 0;
//}


//class Person
//{
//	virtual void func()
//	{}
//
//public:
//	string _name;//姓名
//	string _sex;//性别
//	string _age;//年龄
//};
//
//class Student :public Person
//{
//public:
//	int _No;//学号
//};
//
//int main()
//{
//	Student sobj;
//
//	//1、子类对象可以赋值给父类的对象
//	Person pobj = sobj;
//
//	//2、子类对象可以赋值给父类的指针/引用
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	
//	//3、父类对象不能赋值给子类对象，编译报错
//	//sobj = (Student)pobj;  //err
//
//	return 0;
//}

//class Person
//{
//protected:
//	string _name = "小李子";//姓名
//	int _num = 111;//身份证号
//};
//
//class Student :public Person
//{
//public:
//	void Print()
//	{
//		//Person的_num和Student的_num函数名相同，构成隐藏,
//		//调用_num时会屏蔽父类、而调用子类的_num
//		cout << _num << endl;
//		cout << Person::_num << endl;//显示访问父类的_num
//	}
//
//protected:
//	int _num = 999;//学号
//};
//
//int main()
//{
//	Student s;
//	s.Print();
//
//	return 0;
//}


//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//
//int main()
//{
//	B b;
//	b.fun(10);
//	b.fun();
//
//	return 0;
//};


//class Person
//{
//public:
//	Person(const char* name = "xxx")
//		:_name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		:_name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person& operator=(const Person& p)" << endl;
//		if (this != &p)//p1 = p1
//		{
//			_name = p._name;
//		}
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//
//protected:
//	string _name;//姓名
//};
//
//class Student :public Person
//{
//public:
//	Student(const char* name,int num,const char* address)
//		:Person(name)
//		,_num(num)
//		,_address(address)
//	{}
//
//	//一般Student拷贝构造默认生成的就够用了(默认生成会调用父类的拷贝构造)
//	//有需要深拷贝的资源，才需要自己实现
//	Student(const Student& s)
//		:Person(s)
//		,_num(s._num)
//		,_address(s._address)
//	{
//		//深拷贝
//		_ptr = new int[10];
//		for (int i = 0; i < 10; i++)
//		{
//			_ptr[i] = s._ptr[i];
//		}
//	}
//
//	//一般Student赋值重载默认生成的就够用了
//	//有需要深拷贝的资源，才需要自己实现
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			Person:: operator=(s);
//
//			_num = s._num;
//			_address = s._address;
//		}
//		return *this;
//	}
//
//	//一般Student析构默认生成的就够用了
//	//如果有需要显示释放的资源，才需要自己实现
//	//析构函数都会被特殊处理成destructor() 
//	~Student()
//	{
//		//子类的析构和父类析构函数也构成隐藏关系
//		//规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
//		//这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证
//		
//		//先子后父
//		//Person::~Person();
//		//delete[] _ptr;
//	}
//
//protected:
//	int _num = 1;
//	string _address = "重庆市";
//
//	int* _ptr = new int[10];
//};
//
//int main()
//{
//	Student s1("张三", 1, "重庆市");
//	Student s2(s1);
//
//	Student s3("李四", 2, "北京市");
//	s3 = s1;
//
//	return 0;
//}

////C++11
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//
//protected:
//	int a = 1;
//
//private:
//	//C++98
//	//Base()
//	//{};
//};
//
//class Derive :public Base
//{
//public:
//	void func4() { cout << "Derive::func4" << endl; }
//	
//protected:
//	int b = 2;
//};
//
//int main()
//{
//	Base b;
//	Derive b;
//	return 0;
//}


////前置声明
//class Student;
//
//class Person
//{
//public:
//	//友元关系不能被继承
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name;//姓名
//};
//
//class Student :public Person
//{
//	friend void Display(const Person& p, const Student& s);
//protected:
//	int _stuNum;//学号
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//
//	//编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 
//	//解决方案：Display也变成Student 的友元即可
//	Display(p, s);
//
//	return 0;
//}


//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//
//int Person::_count = 0;
//
//class Student :public Person
//{
//protected:
//	int _stuNum;
//};
//
//int main()
//{
//	Person p;
//	Student s;
//
//	//这里的运行结果可以看到非静态成员_name的地址是不一样的
//    //说明子类继承下来了，父子类对象各有一份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//
//	//这里的运行结果可以看到静态成员_count的地址是一样的
//	//说明子类和父类共用同一份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//
//	//公有的情况下，父子类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//
//	Person::_count++;
//	cout << p._count << endl;
//	cout << s._count << endl;
//
//	return 0;
//}

//class Person
//{
//public:
//	Person(const char* name)
//		:_name(name)
//	{}
//
//	string _name;//姓名
//};
//
//class Student :virtual public Person
//{
//public:
//	Student(const char* name,int num=0)
//		:Person(name)
//		,_num(num)
//	{}
//protected:
//	int _num;//学号
//};
//
//class Teacher :virtual public Person
//{
//public:
//	Teacher(const char* name, int id = 1)
//		:Person(name)
//		,_id(id)
//	{}
//protected:
//	int _id;//职工编号
//};
//
//class Assistant :public Student, public Teacher
//{
//public:
//	Assistant(const char* name1,const char* name2,const char* name3)
//		:Student(name1)
//		,Teacher(name2)
//		,Person(name3)
//	{}
//
//protected:
//	string _majorCourse;//主修课程
//};
//
//int main()
//{
//	//思考⼀下这⾥a对象中_name是"张三", "李四", "王五"中的哪⼀个？
//	Assistant a("张三", "李四", "王五");
//
//	return 0;
//}



//class Person
//{
//public:
//	string _name; //姓名 
//};
//
////使用虚继承Person类 
//class Student :virtual public Person
//{
//protected:
//	int _num; //学号 
//};
//
////使用虚继承Person类 
//class Teacher : virtual public Person
//{
//protected:
//	int _id; //职⼯编号 
//};
//
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; //主修课程 
//};
//
//int main()
//{
//
//	Assistant a;
//
//	// 使用虚继承，可以解决数据冗余和二义性 
//    a._name = "张三";
//
//	return 0;
//}


//class Base1
//{
//public:
//	int _b1;
//};
//
//class Base2
//{
//public:
//	int _b2;
//};
//
//class Derive :public Base1, public Base2
//{
//public :
//	int _d;
//};
//
//int main()
//{
//	Derive d;
//	Base1* p1 = &d;
//	Base2* p2 = &d;
//	Derive* p3 = &d;
//
//	return 0;
//}

//Tire(轮胎)和Car(车)更符合has - a的关系
//class Tire
//{
//protected:
//	string _brand = "Michelin";//品牌
//	size_t _size = 17;//尺寸
//};
//
//class Car
//{
//protected:
//	string _colour = "白色";//颜色
//	string _num = "渝AF0877";//车牌号
//	Tire _t1;//轮胎
//	Tire _t2;//轮胎
//	Tire _t3;//轮胎
//	Tire _t4;//轮胎
//};
//
//class BMW :public Car
//{
//public:
//	void Drive()
//	{
//		cout << "好开-操控" << endl;
//	}
//};
//
//class Benz :public Car
//{
//public:
//	void Drive()
//	{
//		cout << "好坐-舒适" << endl;
//	}
//};
//
//
//
////stack和vector的关系，既符合is-a，也符合has-a 
////继承
//template<class T>
//class stack:public vector<T>
//{};
//
////组合
//template<class T>
//class stack
//{
//public:
//	vector<T> _v;
//};
//
//int main()
//{
//
//	return 0;
//}